{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine and Deep Learning for DDoS Detection\n",
    "### Marcos V. O. Assis (mvoassis@gmail.com)\n",
    "***\n",
    "\n",
    "> ## Published Results:\n",
    "\n",
    "* *A GRU deep learning system against attacks in software defined networks*\n",
    "\n",
    "* https://doi.org/10.1016/j.jnca.2020.102942\n",
    "\n",
    "\n",
    "\n",
    "* \\***Update - 06/2022** - improved detection results through better data cleaning process. Updated results on Git. \n",
    "\n",
    "> ## Objectives\n",
    "\n",
    "1. Evaluate different Machine and Deep Learning methods for anomaly detection.\n",
    "2. Detection of Distributed Denial of Service Attacks\n",
    "\n",
    "> ## Dataset\n",
    "\n",
    "* CIC-DDoS2019 - https://www.unb.ca/cic/datasets/ddos-2019.html\n",
    "\n",
    "> ## Evaluated Methods\n",
    "\n",
    "* Gated Recurrent Units (GRU)\n",
    "* Long-Short Term Memory (LSTM)\n",
    "* Convolutional Neural Network (CNN)\n",
    "* Deep Neural Network (DNN)\n",
    "* Support Vector Machine (SVM)\n",
    "* Logistic Regression (LR)\n",
    "* Gradient Descent (GD)\n",
    "* k Nearest Neighbors (kNN)\n",
    "\n",
    "> ## Environment Config.\n",
    "\n",
    "* Python 3.7.13\n",
    "* Numpy 1.16.4\n",
    "* Scikit-learn 0.21.2\n",
    "* Pandas 0.24.2\n",
    "* Tensorflow 1.14.0\n",
    "* Keras 2.2.4\n",
    "* Matplotlib 3.1.0\n",
    "* Seaborn 0.11.2\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing and treating CIC-DDoS-2019"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.utils import resample\n",
    "from sklearn import preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining functions to load files and downsample them\n",
    "\n",
    "As this research aims to develop a binary detector (Attack or Normal), we should balance the dataset between these two classes. However, CIC-DDOS2019 has few normal flows in it. Thus, downsampling is necessary.\n",
    "\n",
    "For the downsampling process, we allow anomalous flows to be \"mult\" times bigger than normal flows. This approach aims to reduce class disbalance while preventing information losses on attack flows (when the number of attack flows is downsampled to the number of normal ones, ML models could not fit appropriately).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "mult = 5\n",
    "\n",
    "def load_file(path):\n",
    "    data = pd.read_csv(path, sep=',')\n",
    "\n",
    "    is_benign = data[' Label']=='BENIGN'\n",
    "    flows_ok = data[is_benign]\n",
    "    flows_ddos_full = data[~is_benign]\n",
    "    \n",
    "    sizeDownSample = len(flows_ok)*mult # tamanho do set final de dados anomalos\n",
    "    \n",
    "    # downsample majority\n",
    "    if (len(flows_ok)*mult) < (len(flows_ddos_full)): \n",
    "        flows_ddos_reduced = resample(flows_ddos_full,\n",
    "                                         replace = False, # sample without replacement\n",
    "                                         n_samples = sizeDownSample, # match minority n\n",
    "                                         random_state = 27) # reproducible results\n",
    "    else:\n",
    "        flows_ddos_reduced = flows_ddos_full\n",
    "    \n",
    "    return flows_ok, flows_ddos_reduced\n",
    "\n",
    " \n",
    "def load_huge_file(path):\n",
    "    df_chunk = pd.read_csv(path, chunksize=500000)\n",
    "    \n",
    "    chunk_list_ok = []  # append each chunk df here \n",
    "    chunk_list_ddos = [] \n",
    "\n",
    "    # Each chunk is in df format\n",
    "    for chunk in df_chunk:  \n",
    "        # perform data filtering \n",
    "        is_benign = chunk[' Label']=='BENIGN'\n",
    "        flows_ok = chunk[is_benign]\n",
    "        flows_ddos_full = chunk[~is_benign]\n",
    "        \n",
    "        if (len(flows_ok)*mult) < (len(flows_ddos_full)): \n",
    "            sizeDownSample = len(flows_ok)*mult # tamanho do set final de dados anomalos\n",
    "            \n",
    "            # downsample majority\n",
    "            flows_ddos_reduced = resample(flows_ddos_full,\n",
    "                                             replace = False, # sample without replacement\n",
    "                                             n_samples = sizeDownSample, # match minority n\n",
    "                                             random_state = 27) # reproducible results \n",
    "        else:\n",
    "            flows_ddos_reduced = flows_ddos_full\n",
    "            \n",
    "        # Once the data filtering is done, append the chunk to list\n",
    "        chunk_list_ok.append(flows_ok)\n",
    "        chunk_list_ddos.append(flows_ddos_reduced)\n",
    "        \n",
    "    # concat the list into dataframe \n",
    "    flows_ok = pd.concat(chunk_list_ok)\n",
    "    flows_ddos = pd.concat(chunk_list_ddos)\n",
    "    \n",
    "    return flows_ok, flows_ddos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading CIC-DDoS2019 - Day 1 (training)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Users\\mvoas\\Anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3248: DtypeWarning: Columns (85) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  if (await self.run_code(code, result,  async_=asy)):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file 1 loaded\n",
      "file 2 loaded\n",
      "file 3 loaded\n",
      "file 4 loaded\n",
      "file 5 loaded\n",
      "file 6 loaded\n",
      "file 7 loaded\n",
      "file 8 loaded\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Users\\mvoas\\Anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3248: DtypeWarning: Columns (21,85) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  if (await self.run_code(code, result,  async_=asy)):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file 9 loaded\n",
      "file 10 loaded\n",
      "file 11 loaded\n"
     ]
    }
   ],
   "source": [
    "# file 1\n",
    "flows_ok, flows_ddos = load_huge_file('cicddos2019/01-12/TFTP.csv')\n",
    "print('file 1 loaded')\n",
    "\n",
    "# file 2\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_LDAP.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 2 loaded')\n",
    "\n",
    "# file 3\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_MSSQL.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 3 loaded')\n",
    "\n",
    "# file 4\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_NetBIOS.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 4 loaded')\n",
    "\n",
    "# file 5\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_NTP.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 5 loaded')\n",
    "\n",
    "# file 6\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_SNMP.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 6 loaded')\n",
    "\n",
    "# file 7\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_SSDP.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 7 loaded')\n",
    "\n",
    "# file 8\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_UDP.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 8 loaded')\n",
    "\n",
    "# file 9\n",
    "a,b = load_file('cicddos2019/01-12/Syn.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 9 loaded')\n",
    "\n",
    "# file 10\n",
    "a,b = load_file('cicddos2019/01-12/DrDoS_DNS.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 10 loaded')\n",
    "\n",
    "# file 11\n",
    "a,b = load_file('cicddos2019/01-12/UDPLag.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 11 loaded')\n",
    "\n",
    "del a,b\n",
    "\n",
    "samples = flows_ok.append(flows_ddos,ignore_index=True)\n",
    "samples.to_csv(r'cicddos2019/01-12/export_dataframe.csv', index = None, header=True) \n",
    "\n",
    "del flows_ddos, flows_ok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading CIC-DDoS2019 - Day 2 (testing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file 1 loaded\n",
      "file 2 loaded\n",
      "file 3 loaded\n",
      "file 4 loaded\n",
      "file 5 loaded\n"
     ]
    }
   ],
   "source": [
    "# file 1\n",
    "flows_ok, flows_ddos = load_file('cicddos2019/03-11/LDAP.csv')\n",
    "print('file 1 loaded')\n",
    "\n",
    "# file 2\n",
    "a,b = load_file('cicddos2019/03-11/MSSQL.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 2 loaded')\n",
    "\n",
    "# file 3\n",
    "a,b = load_file('cicddos2019/03-11/NetBIOS.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 3 loaded')\n",
    "\n",
    "# file 4\n",
    "a,b = load_file('cicddos2019/03-11/PortMap.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 4 loaded')\n",
    "\n",
    "# file 5\n",
    "a,b = load_file('cicddos2019/03-11/Syn.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 5 loaded')\n",
    "'''\n",
    "# following files won't load**\n",
    "# file 6\n",
    "\n",
    "a,b = load_file('cicddos2019/03-11/UDP.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 6 loaded')\n",
    "\n",
    "# file 7\n",
    "a,b = load_file('cicddos2019/03-11/UDPLag.csv')\n",
    "flows_ok = flows_ok.append(a,ignore_index=True)\n",
    "flows_ddos = flows_ddos.append(b,ignore_index=True)\n",
    "print('file 7 loaded')\n",
    "'''\n",
    "tests = flows_ok.append(flows_ddos,ignore_index=True)\n",
    "tests.to_csv(r'cicddos2019/01-12/export_tests.csv', index = None, header=True) \n",
    "\n",
    "del flows_ddos, flows_ok, a, b\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CIC-DDoS2019 Data Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ProgramData\\Anaconda3\\envs\\PaperGRU\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3186: DtypeWarning: Columns (21,22,85) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data processed\n"
     ]
    }
   ],
   "source": [
    "# training data\n",
    "samples = pd.read_csv('cicddos2019/01-12/export_dataframe.csv', sep=',')\n",
    "\n",
    "def string2numeric_hash(text):\n",
    "    import hashlib\n",
    "    return int(hashlib.md5(text).hexdigest()[:8], 16)\n",
    "\n",
    "# Flows Packet/s e Bytes/s - Replace infinity by 0\n",
    "samples = samples.replace('Infinity','0')\n",
    "samples = samples.replace(np.inf,0)\n",
    "#samples = samples.replace('nan','0')\n",
    "samples[' Flow Packets/s'] = pd.to_numeric(samples[' Flow Packets/s'])\n",
    "\n",
    "samples['Flow Bytes/s'] = samples['Flow Bytes/s'].fillna(0)\n",
    "samples['Flow Bytes/s'] = pd.to_numeric(samples['Flow Bytes/s'])\n",
    "\n",
    "\n",
    "#Label\n",
    "samples[' Label'] = samples[' Label'].replace('BENIGN',0)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_DNS',1)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_LDAP',1)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_MSSQL',1)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_NTP',1)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_NetBIOS',1)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_SNMP',1)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_SSDP',1)\n",
    "samples[' Label'] = samples[' Label'].replace('DrDoS_UDP',1)\n",
    "samples[' Label'] = samples[' Label'].replace('Syn',1)\n",
    "samples[' Label'] = samples[' Label'].replace('TFTP',1)\n",
    "samples[' Label'] = samples[' Label'].replace('UDP-lag',1)\n",
    "samples[' Label'] = samples[' Label'].replace('WebDDoS',1)\n",
    "\n",
    "\n",
    "#Timestamp - Drop day, then convert hour, minute and seconds to hashing \n",
    "colunaTime = pd.DataFrame(samples[' Timestamp'].str.split(' ',1).tolist(), columns = ['dia','horas'])\n",
    "colunaTime = pd.DataFrame(colunaTime['horas'].str.split('.',1).tolist(),columns = ['horas','milisec'])\n",
    "stringHoras = pd.DataFrame(colunaTime['horas'].str.encode('utf-8'))\n",
    "samples[' Timestamp'] = pd.DataFrame(stringHoras['horas'].apply(string2numeric_hash))#colunaTime['horas']\n",
    "del colunaTime,stringHoras\n",
    "\n",
    "\n",
    "# flowID - IP origem - IP destino - Simillar HTTP -> Drop (individual flow analysis)\n",
    "del samples[' Source IP']\n",
    "del samples[' Destination IP']\n",
    "del samples['Flow ID']\n",
    "del samples['SimillarHTTP']\n",
    "del samples['Unnamed: 0']\n",
    "\n",
    "samples.to_csv(r'cicddos2019/01-12/export_dataframe_proc.csv', index = None, header=True) \n",
    "print('Training data processed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ProgramData\\Anaconda3\\envs\\PaperGRU\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3186: DtypeWarning: Columns (85) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test data processed\n"
     ]
    }
   ],
   "source": [
    "# test data\n",
    "tests = pd.read_csv('cicddos2019/01-12/export_tests.csv', sep=',')\n",
    "\n",
    "def string2numeric_hash(text):\n",
    "    import hashlib\n",
    "    return int(hashlib.md5(text).hexdigest()[:8], 16)\n",
    "\n",
    "# Flows Packet/s e Bytes/s - Change infinity by 0\n",
    "tests = tests.replace('Infinity','0')\n",
    "tests = tests.replace(np.inf,0)\n",
    "#amostras = amostras.replace('nan','0')\n",
    "tests[' Flow Packets/s'] = pd.to_numeric(tests[' Flow Packets/s'])\n",
    "\n",
    "tests['Flow Bytes/s'] = tests['Flow Bytes/s'].fillna(0)\n",
    "tests['Flow Bytes/s'] = pd.to_numeric(tests['Flow Bytes/s'])\n",
    "\n",
    "\n",
    "#Label\n",
    "tests[' Label'] = tests[' Label'].replace('BENIGN',0)\n",
    "tests[' Label'] = tests[' Label'].replace('LDAP',1)\n",
    "tests[' Label'] = tests[' Label'].replace('NetBIOS',1)\n",
    "tests[' Label'] = tests[' Label'].replace('MSSQL',1)\n",
    "tests[' Label'] = tests[' Label'].replace('Portmap',1)\n",
    "tests[' Label'] = tests[' Label'].replace('Syn',1)\n",
    "#tests[' Label'] = tests[' Label'].replace('DrDoS_SNMP',1)\n",
    "#tests[' Label'] = tests[' Label'].replace('DrDoS_SSDP',1)\n",
    "\n",
    "#Timestamp - Drop day, then convert hour, minute and seconds to hashing \n",
    "colunaTime = pd.DataFrame(tests[' Timestamp'].str.split(' ',1).tolist(), columns = ['dia','horas'])\n",
    "colunaTime = pd.DataFrame(colunaTime['horas'].str.split('.',1).tolist(),columns = ['horas','milisec'])\n",
    "stringHoras = pd.DataFrame(colunaTime['horas'].str.encode('utf-8'))\n",
    "tests[' Timestamp'] = pd.DataFrame(stringHoras['horas'].apply(string2numeric_hash))#colunaTime['horas']\n",
    "del colunaTime,stringHoras\n",
    "\n",
    "# flowID - IP origem - IP destino - Simillar HTTP -> Deletar (analise fluxo a fluxo)\n",
    "del tests[' Source IP']\n",
    "del tests[' Destination IP']\n",
    "del tests['Flow ID']\n",
    "del tests['SimillarHTTP']\n",
    "del tests['Unnamed: 0']\n",
    "\n",
    "tests.to_csv(r'cicddos2019/01-12/export_tests_proc.csv', index = None, header=True) \n",
    "print('Test data processed')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods implementation\n",
    "\n",
    "Importing required library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# Import required libraries\n",
    "from keras.models import Sequential\n",
    "\n",
    "from keras.layers import Dense,GRU,Embedding,Dropout,Flatten,Conv1D,MaxPooling1D,LSTM\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gated Recurrent Units (GRU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input_size\n",
    "# -> CIC-DDoS2019 82\n",
    "# -> CIC-IDS2018 78\n",
    "\n",
    "def GRU_model(input_size):\n",
    "   \n",
    "    # Initialize the constructor\n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(GRU(32, input_shape=(input_size,1), return_sequences=False)) #\n",
    "    model.add(Dropout(0.5))    \n",
    "    model.add(Dense(10, activation='relu'))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    \n",
    "    model.build()\n",
    "    print(model.summary())\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convolutional Neural Network (CNN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CNN_model(input_size):\n",
    "   \n",
    "    # Initialize the constructor\n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(Conv1D(filters=64, kernel_size=8, activation='relu', input_shape=(input_size,1)))\n",
    "    model.add(MaxPooling1D(2))\n",
    "    model.add(Conv1D(filters=32, kernel_size=16, activation='relu'))\n",
    "    model.add(MaxPooling1D(2))\n",
    "    model.add(Conv1D(filters=16, kernel_size=3, activation='relu'))\n",
    "    model.add(MaxPooling1D(2))\n",
    "    \n",
    "    model.add(Dropout(0.5))\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(10, activation='relu'))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    \n",
    "    print(model.summary())\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Long-Short Term Memory (LSTM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LSTM_model(input_size):\n",
    "   \n",
    "    # Initialize the constructor\n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(LSTM(32,input_shape=(input_size,1), return_sequences=False))\n",
    "    model.add(Dropout(0.5))    \n",
    "    model.add(Dense(10, activation='relu'))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    \n",
    "    print(model.summary())\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deep Neural Network (DNN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "def DNN_model(input_size):\n",
    "   \n",
    "    # Initialize the constructor\n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(Dense(2, activation='relu', input_shape=(input_size,)))\n",
    "    #model.add(Dense(100, activation='relu'))   \n",
    "    #model.add(Dense(40, activation='relu'))\n",
    "    #model.add(Dense(10, activation='relu'))\n",
    "    #model.add(Dropout(0.5))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    \n",
    "    print(model.summary())\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Support Vector Machine (SVM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SVM():\n",
    "    return SVC(kernel='linear')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression (LR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LR():\n",
    "    return LogisticRegression()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradient Descent (GD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GD():\n",
    "    return SGDClassifier()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### k Nearest Neighbors (kNN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kNN():\n",
    "    return KNeighborsClassifier(n_neighbors=3, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Auxiliar Functions\n",
    "\n",
    "Implementation of auxiliar functions, such as testing, compiling/training, 3d reshape, etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### train_test(samples)\n",
    "> Receives a group of samples and split it in train/test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_test(samples):\n",
    "    # Import `train_test_split` from `sklearn.model_selection`\n",
    "    from sklearn.model_selection import train_test_split\n",
    "    import numpy as np\n",
    "    \n",
    "    # Specify the data \n",
    "    X=samples.iloc[:,0:(samples.shape[1]-1)]\n",
    "    \n",
    "    # Specify the target labels and flatten the array\n",
    "    #y= np.ravel(amostras.type)\n",
    "    y= samples.iloc[:,-1]\n",
    "    \n",
    "    # Split the data up in train and test sets\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "    \n",
    "    return X_train, X_test, y_train, y_test\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### normalize_data(X_train,X_test)\n",
    "\n",
    "> Normalize data between -1 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# normalize input data\n",
    "\n",
    "def normalize_data(X_train,X_test):\n",
    "    # Import `StandardScaler` from `sklearn.preprocessing`\n",
    "    from sklearn.preprocessing import StandardScaler,MinMaxScaler\n",
    "    \n",
    "    # Define the scaler \n",
    "    #scaler = StandardScaler().fit(X_train)\n",
    "    scaler = MinMaxScaler(feature_range=(-1, 1)).fit(X_train)\n",
    "    \n",
    "    # Scale the train set\n",
    "    X_train = scaler.transform(X_train)\n",
    "    \n",
    "    # Scale the test set\n",
    "    X_test = scaler.transform(X_test)\n",
    "    \n",
    "    return X_train, X_test\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### format_{2,3}d()\n",
    "\n",
    "> Reshape data in 3d or 2d format (for input in methods such as GRU, CNN and LSTM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reshape data input\n",
    "\n",
    "def format_3d(df):\n",
    "    \n",
    "    X = np.array(df)\n",
    "    return np.reshape(X, (X.shape[0], X.shape[1], 1))\n",
    "\n",
    "def format_2d(df):\n",
    "    \n",
    "    X = np.array(df)\n",
    "    return np.reshape(X, (X.shape[0], X.shape[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### compile_train(model,X_train,y_train,deep=True)\n",
    "\n",
    "> Compile and train learning model\n",
    "\n",
    "> deep = False for scikit-learn ML methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compile and train learning model\n",
    "\n",
    "def compile_train(model,X_train,y_train,deep=True):\n",
    "    \n",
    "    if(deep==True):\n",
    "        import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "        model.compile(loss='binary_crossentropy',\n",
    "                      optimizer='adam',\n",
    "                      metrics=['accuracy'])\n",
    "        \n",
    "        history = model.fit(X_train, y_train,epochs=10, batch_size=256, verbose=1)\n",
    "        #model.fit(X_train, y_train,epochs=3)\n",
    "\n",
    "        # summarize history for accuracy\n",
    "        plt.plot(history.history['acc'])\n",
    "        plt.title('model accuracy')\n",
    "        plt.ylabel('accuracy')\n",
    "        plt.xlabel('epoch')\n",
    "        plt.legend(['train'], loc='upper left')\n",
    "        plt.show()\n",
    "        # summarize history for loss\n",
    "        plt.plot(history.history['loss'])\n",
    "        plt.title('model loss')\n",
    "        plt.ylabel('loss')\n",
    "        plt.xlabel('epoch')\n",
    "        plt.legend(['train'], loc='upper left')\n",
    "        plt.show()\n",
    "\n",
    "        print(model.metrics_names)\n",
    "    \n",
    "    else:\n",
    "        model.fit(X_train, y_train) #SVM, LR, GD\n",
    "    \n",
    "    print('Model Compiled and Trained')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### testes(model,X_test,y_test,y_pred, deep=True)\n",
    "\n",
    "> Testing performance outcomes of the methods\n",
    "\n",
    "> deep = False for scikit-learn ML methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testing performance outcomes of the methods\n",
    "\n",
    "def testes(model,X_test,y_test,y_pred, deep=True):\n",
    "    if(deep==True): \n",
    "        score = model.evaluate(X_test, y_test,verbose=1)\n",
    "\n",
    "        print(score)\n",
    "    \n",
    "    # Alguns testes adicionais\n",
    "    #y_test = formatar2d(y_test)\n",
    "    #y_pred = formatar2d(y_pred)\n",
    "    \n",
    "    \n",
    "    # Import the modules from `sklearn.metrics`\n",
    "    from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, cohen_kappa_score, accuracy_score\n",
    "    \n",
    "    # Accuracy \n",
    "    acc = accuracy_score(y_test, y_pred)\n",
    "    print('\\nAccuracy')\n",
    "    print(acc)\n",
    "    \n",
    "    # Precision \n",
    "    prec = precision_score(y_test, y_pred)#,average='macro')\n",
    "    print('\\nPrecision')\n",
    "    print(prec)\n",
    "    \n",
    "    # Recall\n",
    "    rec = recall_score(y_test, y_pred) #,average='macro')\n",
    "    print('\\nRecall')\n",
    "    print(rec)\n",
    "    \n",
    "    # F1 score\n",
    "    f1 = f1_score(y_test,y_pred) #,average='macro')\n",
    "    print('\\nF1 Score')\n",
    "    print(f1)\n",
    "    \n",
    "    #average\n",
    "    avrg = (acc+prec+rec+f1)/4\n",
    "    print('\\nAverage (acc, prec, rec, f1)')\n",
    "    print(avrg)\n",
    "    \n",
    "    return acc, prec, rec, f1, avrg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### test_normal_atk(y_test,y_pred):\n",
    "\n",
    "> Calculate the correct classification rate of normal and attack flow records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_normal_atk(y_test,y_pred):\n",
    "    df = pd.DataFrame()\n",
    "    df['y_test'] = y_test\n",
    "    df['y_pred'] = y_pred\n",
    "    \n",
    "    normal = len(df.query('y_test == 0'))\n",
    "    atk = len(y_test)-normal\n",
    "    \n",
    "    wrong = df.query('y_test != y_pred')\n",
    "    \n",
    "    normal_detect_rate = (normal - wrong.groupby('y_test').count().iloc[0][0]) / normal\n",
    "    atk_detect_rate = (atk - wrong.groupby('y_test').count().iloc[1][0]) / atk\n",
    "    \n",
    "    #print(normal_detect_rate,atk_detect_rate)\n",
    "    \n",
    "    return normal_detect_rate, atk_detect_rate\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving and Loading methods\n",
    "\n",
    "> Methods for saving and loading trained models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save model and weights\n",
    "\n",
    "def save_model(model,name):\n",
    "    from keras.models import model_from_json\n",
    "    \n",
    "    arq_json = 'Models/' + name + '.json'\n",
    "    model_json = model.to_json()\n",
    "    with open(arq_json,\"w\") as json_file:\n",
    "        json_file.write(model_json)\n",
    "    \n",
    "    arq_h5 = 'Models/' + name + '.h5'\n",
    "    model.save_weights(arq_h5)\n",
    "    print('Model Saved')\n",
    "    \n",
    "def load_model(name):\n",
    "    from keras.models import model_from_json\n",
    "    \n",
    "    arq_json = 'Models/' + name + '.json'\n",
    "    json_file = open(arq_json,'r')\n",
    "    loaded_model_json = json_file.read()\n",
    "    json_file.close()\n",
    "    loaded_model = model_from_json(loaded_model_json)\n",
    "    \n",
    "    arq_h5 = 'Models/' + name + '.h5'\n",
    "    loaded_model.load_weights(arq_h5)\n",
    "    \n",
    "    print('Model loaded')\n",
    "    \n",
    "    return loaded_model\n",
    "\n",
    "def save_Sklearn(model,nome):\n",
    "    import pickle\n",
    "    arquivo = 'Models/'+ nome + '.pkl'\n",
    "    with open(arquivo,'wb') as file:\n",
    "        pickle.dump(model,file)\n",
    "    print('Model sklearn saved')\n",
    "\n",
    "def load_Sklearn(nome):\n",
    "    import pickle\n",
    "    arquivo = 'Models/'+ nome + '.pkl'\n",
    "    with open(arquivo,'rb') as file:\n",
    "        model = pickle.load(file)\n",
    "    print('Model sklearn loaded')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main script for testing the learning methods\n",
    "\n",
    "> **Dataset - CIC-DDoS2019**\n",
    "\n",
    "Loading training dataset (day 1), upsampling normal flows for balancing the training set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "# UPSAMPLE OF NORMAL FLOWS\n",
    "    \n",
    "samples = pd.read_csv('cicddos2019/01-12/export_dataframe_proc.csv', sep=',')\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test(samples)\n",
    "\n",
    "\n",
    "#junta novamente pra aumentar o numero de normais\n",
    "X = pd.concat([X_train, y_train], axis=1)\n",
    "\n",
    "# separate minority and majority classes\n",
    "is_benign = X[' Label']==0 #base de dados toda junta\n",
    "\n",
    "normal = X[is_benign]\n",
    "ddos = X[~is_benign]\n",
    "\n",
    "# upsample minority\n",
    "normal_upsampled = resample(normal,\n",
    "                          replace=True, # sample with replacement\n",
    "                          n_samples=len(ddos), # match number in majority class\n",
    "                          random_state=27) # reproducible results\n",
    "\n",
    "# combine majority and upsampled minority\n",
    "upsampled = pd.concat([normal_upsampled, ddos])\n",
    "\n",
    "# Specify the data \n",
    "X_train=upsampled.iloc[:,0:(upsampled.shape[1]-1)]    #DDoS\n",
    "y_train= upsampled.iloc[:,-1]  #DDoS\n",
    "\n",
    "input_size = (X_train.shape[1], 1)\n",
    "\n",
    "del X, normal_upsampled, ddos, upsampled, normal #, l1, l2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing the test dataset (day 2) and normalizing data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "tests = pd.read_csv('cicddos2019/01-12/export_tests_proc.csv', sep=',')\n",
    "\n",
    "# X_test = np.concatenate((X_test,(tests.iloc[:,0:(tests.shape[1]-1)]).to_numpy())) # testar 33% + dia de testes\n",
    "# y_test = np.concatenate((y_test,tests.iloc[:,-1]))\n",
    "\n",
    "del X_test,y_test                            # testar só o dia de testes\n",
    "X_test = tests.iloc[:,0:(tests.shape[1]-1)]                        \n",
    "y_test = tests.iloc[:,-1]\n",
    "\n",
    "# print((y_test.shape))\n",
    "# print((X_test.shape))\n",
    "\n",
    "X_train, X_test = normalize_data(X_train,X_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compiling and Training the methods\n",
    "\n",
    "> Comment the last 2 code blocks\n",
    "\n",
    "**OR**\n",
    "\n",
    "Loading and compiling the methods\n",
    "\n",
    "> Comment the first 2 code blocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model loaded\n",
      "Model loaded\n",
      "Model loaded\n",
      "Model loaded\n",
      "Model sklearn loaded\n",
      "Model sklearn loaded\n",
      "Model sklearn loaded\n",
      "Model sklearn loaded\n"
     ]
    }
   ],
   "source": [
    "\n",
    "## Comment next 2 blocks if loading pre-trained models\n",
    "## Execute them if training new models\n",
    "\n",
    "# model_gru = GRU_model() #quando treina novo modelo\n",
    "# model_cnn = CNN_model()\n",
    "# model_lstm = LSTM_model()\n",
    "# model_dnn = DNN_model(X_train.shape[1])\n",
    "# model_svm = SVM()\n",
    "# model_lr = LR()\n",
    "# model_gd = GD()\n",
    "# model_knn = kNN()\n",
    " \n",
    "# model_gru = compile_train(model_gru,format_3d(X_train),y_train)  #quando treina novo modelo, ou retreina\n",
    "# model_cnn = compile_train(model_cnn,format_3d(X_train),y_train)\n",
    "# model_lstm = compile_train(model_lstm,format_3d(X_train),y_train)\n",
    "# model_dnn = compile_train(model_dnn,X_train,y_train)\n",
    "# model_svm = compile_train(model_svm,X_train,y_train,False)\n",
    "# model_lr = compile_train(model_lr,X_train,y_train,False)\n",
    "# model_gd = compile_train(model_gd,X_train,y_train,False)\n",
    "# model_knn = compile_train(model_knn,X_train,y_train,False)\n",
    "\n",
    "## Comment next 2 blocks if training new models\n",
    "## Execute them if loading pre-trained models\n",
    "\n",
    "model_gru = load_model('GRU20-32-b256') #when loading previously saved trained model and weights\n",
    "model_cnn = load_model('CNN5-3cam-b2560')\n",
    "model_lstm = load_model('LSTM5-32-b256')\n",
    "model_dnn = load_model('DNN5-2560')\n",
    "model_svm = load_Sklearn('SVM') \n",
    "model_lr = load_Sklearn('LR')\n",
    "model_gd = load_Sklearn('GD')\n",
    "model_knn = load_Sklearn('kNN-1viz')\n",
    "\n",
    "model_gru.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) #qdo carrega modelo salvo\n",
    "model_cnn.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "model_lstm.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "model_dnn.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing CIC-DDoS2019 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = pd.DataFrame(columns=['Method','Accuracy','Precision','Recall', 'F1_Score', 'Average','Normal_Detect_Rate','Atk_Detect_Rate'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "298578/298578 [==============================] - 76s 253us/step\n",
      "[0.01105657341191673, 0.9985832847698088]\n",
      "\n",
      "Accuracy\n",
      "0.9985832847698088\n",
      "\n",
      "Precision\n",
      "0.9995093228655545\n",
      "\n",
      "Recall\n",
      "0.9987902658601773\n",
      "\n",
      "F1 Score\n",
      "0.9991496649921299\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9990081346219176\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_gru.predict(format_3d(X_test)) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_gru,format_3d(X_test),y_test,y_pred)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'GRU', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "298578/298578 [==============================] - 54s 182us/step\n",
      "[0.029455807720052126, 0.9877251505469258]\n",
      "\n",
      "Accuracy\n",
      "0.9877251505469258\n",
      "\n",
      "Precision\n",
      "0.9942101910314407\n",
      "\n",
      "Recall\n",
      "0.9910415368848341\n",
      "\n",
      "F1 Score\n",
      "0.9926233352185928\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9914000534204483\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_cnn.predict(format_3d(X_test)) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_cnn,format_3d(X_test),y_test,y_pred)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'CNN', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "298578/298578 [==============================] - 85s 283us/step\n",
      "[0.07657973352144937, 0.978297128388961]\n",
      "\n",
      "Accuracy\n",
      "0.9782971283885618\n",
      "\n",
      "Precision\n",
      "0.9991801691570573\n",
      "\n",
      "Recall\n",
      "0.9747563450756587\n",
      "\n",
      "F1 Score\n",
      "0.9868171572257439\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9847626999617554\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_lstm.predict(format_3d(X_test)) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_lstm,format_3d(X_test),y_test,y_pred)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'LSTM', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "298578/298578 [==============================] - 15s 50us/step\n",
      "[0.043137314041730386, 0.9974412046433427]\n",
      "\n",
      "Accuracy\n",
      "0.9974412046433427\n",
      "\n",
      "Precision\n",
      "0.9981403904778353\n",
      "\n",
      "Recall\n",
      "0.9987902658601773\n",
      "\n",
      "F1 Score\n",
      "0.9984652224222165\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9982092708508931\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_dnn.predict(X_test) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_dnn,X_test,y_test,y_pred)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'DNN', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy\n",
      "0.9986502689414491\n",
      "\n",
      "Precision\n",
      "0.9991480332427783\n",
      "\n",
      "Recall\n",
      "0.9992323613930029\n",
      "\n",
      "F1 Score\n",
      "0.9991901955386405\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9990552147789676\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_svm.predict(X_test) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_svm,X_test,y_test,y_pred,False)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'SVM', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy\n",
      "0.9985799355612269\n",
      "\n",
      "Precision\n",
      "0.9990677302043358\n",
      "\n",
      "Recall\n",
      "0.9992283423427044\n",
      "\n",
      "F1 Score\n",
      "0.9991480298189563\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9990060094818058\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_lr.predict(X_test) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_lr,X_test,y_test,y_pred,False)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'LR', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy\n",
      "0.9986804118186873\n",
      "\n",
      "Precision\n",
      "0.9992042344373576\n",
      "\n",
      "Recall\n",
      "0.9992122661415107\n",
      "\n",
      "F1 Score\n",
      "0.9992082502732943\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9990762906677125\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_gd.predict(X_test) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_gd,X_test,y_test,y_pred,False)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'GB', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### kNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ProgramData\\Anaconda3\\envs\\PaperGRU\\lib\\site-packages\\sklearn\\neighbors\\base.py:441: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
      "  old_joblib = LooseVersion(joblib_version) < LooseVersion('0.12')\n",
      "D:\\ProgramData\\Anaconda3\\envs\\PaperGRU\\lib\\site-packages\\sklearn\\neighbors\\base.py:441: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
      "  old_joblib = LooseVersion(joblib_version) < LooseVersion('0.12')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy\n",
      "0.9991258565600949\n",
      "\n",
      "Precision\n",
      "0.9995578316061968\n",
      "\n",
      "Recall\n",
      "0.9993931234049395\n",
      "\n",
      "F1 Score\n",
      "0.999475470719811\n",
      "\n",
      "Average (acc, prec, rec, f1)\n",
      "0.9993880705727606\n"
     ]
    }
   ],
   "source": [
    "y_pred = model_knn.predict(X_test) \n",
    "\n",
    "y_pred = y_pred.round()\n",
    " \n",
    "acc, prec, rec, f1, avrg = testes(model_knn,X_test,y_test,y_pred,False)\n",
    "\n",
    "norm, atk = test_normal_atk(y_test,y_pred)\n",
    "\n",
    "results = results.append({'Method':'kNN', 'Accuracy':acc, 'Precision':prec, 'F1_Score':f1,\n",
    "                          'Recall':rec,'Average':avrg, 'Normal_Detect_Rate':norm, 'Atk_Detect_Rate':atk}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discussion and Results\n",
    "\n",
    "Showing the table 'results', containing the performance metrics outcomes for each method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Method</th>\n",
       "      <th>Accuracy</th>\n",
       "      <th>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>F1_Score</th>\n",
       "      <th>Average</th>\n",
       "      <th>Normal_Detect_Rate</th>\n",
       "      <th>Atk_Detect_Rate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GRU</td>\n",
       "      <td>0.998583</td>\n",
       "      <td>0.999509</td>\n",
       "      <td>0.998790</td>\n",
       "      <td>0.999150</td>\n",
       "      <td>0.999008</td>\n",
       "      <td>0.997548</td>\n",
       "      <td>0.998790</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CNN</td>\n",
       "      <td>0.987725</td>\n",
       "      <td>0.994210</td>\n",
       "      <td>0.991042</td>\n",
       "      <td>0.992623</td>\n",
       "      <td>0.991400</td>\n",
       "      <td>0.971143</td>\n",
       "      <td>0.991042</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>LSTM</td>\n",
       "      <td>0.978297</td>\n",
       "      <td>0.999180</td>\n",
       "      <td>0.974756</td>\n",
       "      <td>0.986817</td>\n",
       "      <td>0.984763</td>\n",
       "      <td>0.996001</td>\n",
       "      <td>0.974756</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DNN</td>\n",
       "      <td>0.997441</td>\n",
       "      <td>0.998140</td>\n",
       "      <td>0.998790</td>\n",
       "      <td>0.998465</td>\n",
       "      <td>0.998209</td>\n",
       "      <td>0.990696</td>\n",
       "      <td>0.998790</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>SVM</td>\n",
       "      <td>0.998650</td>\n",
       "      <td>0.999148</td>\n",
       "      <td>0.999232</td>\n",
       "      <td>0.999190</td>\n",
       "      <td>0.999055</td>\n",
       "      <td>0.995740</td>\n",
       "      <td>0.999232</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>LR</td>\n",
       "      <td>0.998580</td>\n",
       "      <td>0.999068</td>\n",
       "      <td>0.999228</td>\n",
       "      <td>0.999148</td>\n",
       "      <td>0.999006</td>\n",
       "      <td>0.995338</td>\n",
       "      <td>0.999228</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>GB</td>\n",
       "      <td>0.998680</td>\n",
       "      <td>0.999204</td>\n",
       "      <td>0.999212</td>\n",
       "      <td>0.999208</td>\n",
       "      <td>0.999076</td>\n",
       "      <td>0.996021</td>\n",
       "      <td>0.999212</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>kNN</td>\n",
       "      <td>0.999126</td>\n",
       "      <td>0.999558</td>\n",
       "      <td>0.999393</td>\n",
       "      <td>0.999475</td>\n",
       "      <td>0.999388</td>\n",
       "      <td>0.997790</td>\n",
       "      <td>0.999393</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Method  Accuracy  Precision    Recall  F1_Score   Average  \\\n",
       "0    GRU  0.998583   0.999509  0.998790  0.999150  0.999008   \n",
       "1    CNN  0.987725   0.994210  0.991042  0.992623  0.991400   \n",
       "2   LSTM  0.978297   0.999180  0.974756  0.986817  0.984763   \n",
       "3    DNN  0.997441   0.998140  0.998790  0.998465  0.998209   \n",
       "4    SVM  0.998650   0.999148  0.999232  0.999190  0.999055   \n",
       "5     LR  0.998580   0.999068  0.999228  0.999148  0.999006   \n",
       "6     GB  0.998680   0.999204  0.999212  0.999208  0.999076   \n",
       "7    kNN  0.999126   0.999558  0.999393  0.999475  0.999388   \n",
       "\n",
       "   Normal_Detect_Rate  Atk_Detect_Rate  \n",
       "0            0.997548         0.998790  \n",
       "1            0.971143         0.991042  \n",
       "2            0.996001         0.974756  \n",
       "3            0.990696         0.998790  \n",
       "4            0.995740         0.999232  \n",
       "5            0.995338         0.999228  \n",
       "6            0.996021         0.999212  \n",
       "7            0.997790         0.999393  "
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Classification Metrics:**\n",
    "* Accuracy\n",
    "* Precision\n",
    "* Recall\n",
    "* F1 Measure (F1 Score)\n",
    "\n",
    "Showing performance outcomes of the methods: \n",
    "* GRU\n",
    "* DNN\n",
    "* SVM\n",
    "* LR\n",
    "* GB\n",
    "* kNN\n",
    "\n",
    "LSTM and CNN were separated for visualization improvement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.catplot(data=results.iloc[:,:5].query('Method != \"LSTM\" and Method != \"CNN\"'), col='Method', col_wrap=3, kind='bar', height=3, aspect=2)\n",
    "ax.set(ylim=(0.99,1))\n",
    "ax.set_xticklabels(rotation=45)\n",
    "ax = ax\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> As observed, the evaluated methods achieved good performance outcomes close to 1. As the evaluated methods achieved similar outcomes, a more specific analysis should be performed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Showing results of the LSTM and CNN methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA20AAADrCAYAAAD6836SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deViVdf7/8edhUxEUURYXCguTMcVMJ5dG1MlcUMTMTMfUCZdycokpk0lJxS2NQocyzWm0nExjVJBSU8fc0sZ9m6/auJujCELDksCBc35/+OOMpgnl0XMfeD2uy0vuc59z8765ue8X73N/zn2brFarFRERERERETEkF0cXICIiIiIiIj9NTZuIiIiIiIiBqWkTERERERExMDVtIiIiIiIiBqamTURERERExMDUtImIiIiIiBiYmjaRO/Ddd9/RuHFjnnvuuZvmxcbG0rhxY7Kysm67jPPnzzN69Gjb8lq0aHHHdbVo0YLvvvvujpaRk5PDtGnTiIyMJCoqit69e5OcnGybP2jQIAYNGoTFYrE9lpWVRePGjYH//Wyufw3Ahx9+SGxs7B3VJiJS2VXU/Fm5ciUvvPDCLefl5eUxceJEIiMj6dWr1w25tGPHDqKiooiKiuLxxx+nTZs2tuk1a9aQlJRE48aNWbFixQ3L/OGHH2jRosVPfk8Ro3BzdAEizq5KlSqcPn2aCxcuUL9+feBaCOzbt69cr//Pf/7D6dOn72aJP1thYSHPPfcckZGRrFq1Cjc3Ny5cuMDvf/97AJ555hkADhw4wPz58/nDH/5wy+W4uLgwa9YsWrZsyQMPPHCvyhcRqRQqYv7czttvv42npyerV6/GZDKRnp7Os88+S926dfnNb35DamoqAElJSWRnZ/PGG2/YXpuUlES9evVITU3l6aeftj2+fv16PD097/m6iPxcOtMmcodcXV3p3r07aWlptsfWr1/PE088ccPzNm3axDPPPEPv3r3p378/+/fvp6SkhIkTJ3Lu3DmGDh0KQElJCW+88QZPPfUUnTt35ssvvwTAbDYzdepUIiIiiIyMZMKECeTl5QGwZ88e29mwuLi4G85+Xa9///62dx5L/02ZMuWm561ZswZPT0+GDx+Om9u193bq16/PnDlzaNSoke15f/jDH/jrX//KgQMHbvn9qlatyvPPP8+rr75KUVFReX+kIiJSDhUxf24nIyODwsJCzGYzAAEBASQlJXH//feX6/Xt27fnxIkTXLp0yfbYqlWr6NWr18+qQ8QR1LSJ2EHv3r1t7/ABpKSk8NRTT9mmz5w5Q2JiIh988AEpKSlMnTqV0aNHU1hYyLRp07jvvvv48MMPgWtnuR5//HFWrVrF+PHjeeuttwB4//33uXz5MqmpqaSmpmKxWJg9ezZFRUWMHTuW2NhYUlJSaN26NQUFBbesc9myZbbXl/6bNGnSTc87cuQIjz766E2PP/zwwzzyyCO26YYNG/Laa6/x6quv2gL8x0aOHImnpyeJiYnl+EmKiMjPUdHy53ZGjRrFN998Q5s2bRg6dCjvvfceXl5eBAUFlev1bm5udO/endWrVwPXzjTm5+ff8GakiFFpeKSIHTRt2hRXV1eOHDlC7dq1yc/P56GHHrLN//rrr7l8+bJteCGAyWTi3LlzNy3L3d2drl27AhAaGsqVK1cA2Lp1KzExMbi7uwPXPlP20ksv8e233+Lm5kbbtm0B6Nmz5w1DQq7Xv39/rl69esNjjz766E3BaTKZsFqt5Vr3fv36sX37diZPnszrr79+03wXFxfeeustevfuzW9+85tyLVNERMqnouXP7YSGhrJu3Tr+9a9/sXv3br7++mvmz5/P3Llz+e1vf1uuZURFRTFhwgRGjBhBamoqvXv3Lvf3F3EkNW0idtKrVy9Wr16Nr68vUVFRN8yzWCy0bduWOXPm2B67ePEi/v7+7Nmz54bnloYiXAvW65fx4+nSISI/brBKhzT+2LJly8q1Lo888giffPLJTY//4x//YM+ePYwfP/6Gx6dOnWpb/1upW7cuU6ZMYfz48QpIERE7q0j581OKi4uJj4/nj3/8I02bNqVp06Y8//zzzJs3j+XLl5e7aQsLC6OkpISjR4+yZs0alixZwqZNm+6oNpF7QcMjRewkKiqKdevWsWbNGnr27HnDvLZt2/L1119z8uRJALZs2UKvXr0oKCjA1dXVFn630759ez799FPMZjMWi4VPPvmExx9/nMaNG2O1WtmyZQtwrbH673//e0fr0qVLF/Ly8li4cCElJSXAtauMvfnmmzz44IM3Pb9mzZq89dZbtx0C2a1bN8LDw/noo4/uqDYREblRRcqfn+Lm5sbp06eZN2+erebi4mJOnjxJkyZNftayoqKimDFjBg0bNsTHx+dulCtid2raROwkICCABx98kODg4JtCICQkxPYOYa9evZg7dy7vv/8+1atXJyQkhCpVqtC3b9/bDkkcOXIkderUoXfv3nTv3p3i4mImTJiAu7s77733HnPnziUqKooNGzZQu3btO1oXDw8PFi1axIkTJ4iMjCQyMpLRo0czcuRI+vbte8vXPPbYYzcMv7mViRMnUq9evTuqTUREblSR8gdg27ZttGjRwvYvPDwcgLlz55Kbm0vXrl3p0aMHkZGR1K9fn5deeulnLb9Xr17s2bPnhs/+iRidyVreD66IiIiIiIjIPaczbSIiIiIiIgZWrqYtLy+Pnj173vIO90ePHqVPnz507dqVCRMmUFxcDFy7jOrAgQPp1q0bI0eOJD8/H4CcnBxGjBhB9+7dGThwIBkZGXZcHRERERERkYqlzKbt4MGDDBgwgDNnztxy/rhx43jjjTf48ssvsVqtfPbZZwBMmTKF3/3ud6xbt46mTZsyb948AObMmUOrVq1Yu3YtzzzzDNOnT7ff2oiIiIiIiFQwZTZtn332GZMmTcLf3/+meRcuXKCgoMB2s90+ffqwbt06zGYzu3fvtt3ro/RxgM2bNxMZGQlcu5/H1q1by3XlIhERERERkcqozPu03e5M2OXLl/Hz87NN+/n5kZ6eTnZ2Nl5eXrZ7dZQ+/uPXuLm54eXlRVZWFgEBAXe0IiIiIiIiIhXRHV2I5Mc3W7RarZhMJtv/1/vx9PWvcXHR9VBERERERERupcwzbbcTGBh4w4VEMjMz8ff3x9fXl9zcXEpKSnB1dSUjI8M2vNLf35/MzEwCAwMpLi4mPz//Z9/Y8MqVPCwW3alARETsw8/P+xe9TnkkIiL2crssuqNTXPXr16dKlSrs3bsXgNTUVMLDw3F3d6dVq1asWbMGgJSUFNuNETt06EBKSgoAa9asoVWrVri7u99JGSIiIiIiIhXWL2rahg8fzuHDhwFISEhg5syZdOvWjR9++IHBgwcDMGnSJD777DMiIiLYs2cPL7/8MgBjx47lwIED9OjRg6VLl/LGG2/YaVVEREREREQqHpPVanW6cR0ajiIiIvak4ZGVS62aHrh5VHF0GU6vuKiQ7P8WOboMkQrjdll0R59pExEREXE2bh5V2Dt7mKPLcHotX/sLoKZN5F7QZRtFREREREQMTE2biIiIiIiIgalpExERERERMTA1bSIiIiIiIgampk1ERERERMTA1LSJiIiIiIgYmJo2ERERERERA1PTJiIiIiIiYmBq2kRERERERAxMTZuIiIiIiIiBqWkTERERERExMDVtIiIiIiIiBqamTURERERExMDUtImIiIiIiBiYmjYREREREREDU9MmIiIiIiJiYOVq2tLS0oiIiKBLly588sknN83fsmULkZGRREZG8sorr5Cfnw/AoUOHePrpp4mMjOSFF14gIyMDgF27dtG6dWuioqKIioriT3/6kx1XSUREREREpOIos2lLT08nMTGRpUuXkpKSwvLlyzlx4oRtfk5ODrGxsSQmJpKWlkZoaCiJiYlYrVbGjBnDuHHjSEtLIyoqiri4OACOHDlCdHQ0qamppKamMnPmzLu3hiIiIiIiIk6szKZtx44dtGnTBh8fHzw9PenatSvr1q2zzT9z5gz16tUjJCQEgE6dOrFx40ays7MpKCigTZs2tse3b99OUVERhw8fZvv27URGRvLiiy9y8eLFu7R6IiIiIiIizq3Mpu3y5cv4+fnZpv39/UlPT7dNBwcHc+nSJY4dOwbA2rVryczMpFatWnh6erJ9+3YAvvjiC8xmM9nZ2Xh7ezNo0CDS0tLo0KEDMTEx9l4vERERERGRCsGtrCdYLBZMJpNt2mq13jBdo0YNZs2aRVxcHBaLhX79+uHu7o7JZOLPf/4zs2bNIiEhgaioKHx8fHB3dyc+Pt72+gEDBvD222+Tm5uLt7d3uYquXdvr56yjiIjIXaE8ksrOz698f7uJyJ0ps2kLDAxkz549tumMjAz8/f1t0yUlJQQGBpKcnAxcu/hIUFDQtYW7ubFkyRIArly5wrx58/Dx8eH9999nxIgRuLq62pZz/ddluXIlD4vFWu7ni4iI3M4v/cNTeeSc1GjYT0ZGrqNLEKkwbndsKnN4ZLt27di5cydZWVlcvXqV9evXEx4ebptvMpmIjo4mPT0dq9XK4sWLiYiIAOD111/n0KFDACxatIhu3brh4uLChg0b+PLLLwFISUmhefPmeHp63tFKioiIiIiIVERlnmkLCAggJiaGwYMHYzab6du3L2FhYQwfPpwxY8bQrFkz4uPjGTZsGEVFRbRt25ahQ4cCMHnyZCZNmsTVq1dp3Lgx06dPB7ANp3zvvffw9fVl9uzZd3ctRUREREREnJTJarU63bgODUdxXrVqeuDmUcXRZTi14qJCsv9b5OgyRCoUDY+sXPz8vNk7e5ijy3B6LV/7i4ZHitjR7bKozDNtIvbk5lFFQXmHWr72F0BNm4iIiEhlUeZn2kRERERERMRx1LSJiIiIiIgYmJo2ERERERERA1PTJiIiIiIiYmBq2kRERERERAxMTZuIiIiIiIiB6ZL/IiIG5OPtgXtV3dPwTpkLCvk+V7fIEBER56amTUTEgNyrVmHN4OcdXYbTi/h4EahpExERJ6fhkSIiIiIiIgampk1ERERERMTA1LSJiIiIiIgYmJo2ERERERERA1PTJiIiIiIiYmBq2kRERERERAxMTZuIiIiIiIiB6T5tIkKNmlWo4uHh6DKcWmFRETn/LXR0GSIiIlIBlatpS0tL4/3336e4uJghQ4YwcODAG+Zv2bKFhIQEAB566CHi4+OpXr06hw4dYsqUKRQVFVGvXj2mTZuGn58fOTk5vPrqq5w/fx5fX1/mzJmDn5+f/ddORMqliocHv1801tFlOLXFz88F1LSJiIiI/ZU5PDI9PZ3ExESWLl1KSkoKy5cv58SJE7b5OTk5xMbGkpiYSFpaGqGhoSQmJmK1WhkzZgzjxo0jLS2NqKgo4uLiAJgzZw6tWrVi7dq1PPPMM0yfPv3uraGIiIiIiIgTK7Np27FjB23atMHHxwdPT0+6du3KunXrbPPPnDlDvXr1CAkJAaBTp05s3LiR7OxsCgoKaNOmje3x7du3U1RUxObNm4mMjASgZ8+ebN26FbPZfDfWT0RERERExKmV2bRdvnz5hqGL/v7+pKen26aDg4O5dOkSx44dA2Dt2rVkZmZSq1YtPD092b59OwBffPEFZrOZ7OzsG5bp5uaGl5cXWVlZdl0xERERERGRiqDMz7RZLBZMJpNt2mq13jBdo0YNZs2aRVxcHBaLhX79+uHu7o7JZOLPf/4zs2bNIiEhgaioKHx8fHB3d7/pe1itVlxcyn8hy9q1vcr9XJGKyM/P29ElyC1ouxjT3dwuyiOp7HTcE7k3ymzaAgMD2bNnj206IyMDf39/23RJSQmBgYEkJycDcOjQIYKCgq4t3M2NJUuWAHDlyhXmzZuHj48P/v7+ZGZmEhgYSHFxMfn5+fj4+JS76CtX8rBYrOV+vhiHDu72kZGRa9flabvYhz23i7aJ/ZRnu/zSn7fyyDlp/7Ife+eRSGV2u2NTmae32rVrx86dO8nKyuLq1ausX7+e8PBw23yTyUR0dDTp6elYrVYWL15MREQEAK+//jqHDh0CYNGiRXTr1g0XFxc6dOhASkoKAGvWrKFVq1a3PAMnIiIiIiJS2ZV5pi0gIICYmBgGDx6M2Wymb9++hIWFMXz4cMaMGUOzZs2Ij49n2LBhFBUV0bZtW4YOHQrA5MmTmTRpElevXqVx48a2q0SOHTuW2NhYevTogbe3t+12ASIiIiIiInKjct2nLTIy0na1x1ILFy60fd2xY0c6dux40+vCwsJYtWrVTY/7+Pgwf/78n1mqiIiIiIhI5VP+q3+IiIiIiIjIPaemTURERERExMDUtImIiIiIiBiYmjYREREREREDU9MmIiIiIiJiYGraREREREREDExNm4iIiIiIiIGV6z5tzsi7RlWqVnF3dBlOr6DQTG5OgaPLEBERERGptCps01a1iju/e+0TR5fh9JbOHkguatpERERERBxFwyNFREREREQMTE2biIiIiIiIgalpExERERERMbAK+5k2ERERERG5Mz7eHrhXreLoMpyauaCQ73OL7mgZatpEREREROSW3KtWYc3g5x1dhlOL+HgR3GHTpuGRIiIiIiIiBqamTURERERExMDUtImIiIiIiBhYuZq2tLQ0IiIi6NKlC598cvMNq7ds2UJkZCSRkZG88sor5OfnA/Ddd98xcOBAoqKiGDRoEBcuXABg165dtG7dmqioKKKiovjTn/5kx1USERERERGpOMps2tLT00lMTGTp0qWkpKSwfPlyTpw4YZufk5NDbGwsiYmJpKWlERoaSmJiIgBz586lR48epKam0qVLF9vjR44cITo6mtTUVFJTU5k5c+ZdWj0RERERERHnVmbTtmPHDtq0aYOPjw+enp507dqVdevW2eafOXOGevXqERISAkCnTp3YuHEjABaLhby8PACuXr1K1apVATh8+DDbt28nMjKSF198kYsXL9p9xURERERERCqCMpu2y5cv4+fnZ5v29/cnPT3dNh0cHMylS5c4duwYAGvXriUzMxOAsWPHsnjxYtq3b89f//pXhg8fDoC3tzeDBg0iLS2NDh06EBMTY9eVEhERERERqSjKvE+bxWLBZDLZpq1W6w3TNWrUYNasWcTFxWGxWOjXrx/u7u4AjB8/nvj4eDp37syXX37JqFGjWL16NfHx8bbXDxgwgLfffpvc3Fy8vb3LVXTt2l7lXkG5c35+5dsucu9omxiTtosx3c3tojySyk7HPZHyudN9pcymLTAwkD179timMzIy8Pf3t02XlJQQGBhIcnIyAIcOHSIoKIisrCxOnTpF586dAejatSuTJk3iypUrJCcnM2LECFxdXW3Luf7rsly5kofFYr3tc3QQsZ+MjFy7LUvbxT7suU1A28VetK8YU3m2yy/9eZcnj8R4tH/Zj73zSIxH+4t93GkWlTk8sl27duzcuZOsrCyuXr3K+vXrCQ8Pt803mUxER0eTnp6O1Wpl8eLFREREUKtWLapUqWJr+Pbu3Uv16tWpU6cOGzZs4MsvvwQgJSWF5s2b4+npWeaKiIiIiIiIVDZlnmkLCAggJiaGwYMHYzab6du3L2FhYQwfPpwxY8bQrFkz4uPjGTZsGEVFRbRt25ahQ4diMpl49913mTp1KgUFBVSvXp2kpCQA23DK9957D19fX2bPnn3XV1RERERERMQZldm0AbZ7sF1v4cKFtq87duxIx44db3pdWFiYbdjk9Ro1asSyZct+ZqkiIiIiIiKVT7luri0iIiIiIiKOoaZNRERERETEwNS0iYiIiIiIGJiaNhEREREREQNT0yYiIiIiImJgatpEREREREQMTE2biIiIiIiIgalpExERERERMTA1bSIiIiIiIgampk1ERERERMTA1LSJiIiIiIgYmJo2ERERERERA1PTJiIiIiIiYmBq2kRERERERAxMTZuIiIiIiIiBqWkTERERERExMDVtIiIiIiIiBqamTURERERExMDK1bSlpaURERFBly5d+OSTT26av2XLFiIjI4mMjOSVV14hPz8fgO+++46BAwcSFRXFoEGDuHDhAgA5OTmMGDGC7t27M3DgQDIyMuy4SiIiIiIiIhVHmU1beno6iYmJLF26lJSUFJYvX86JEyds83NycoiNjSUxMZG0tDRCQ0NJTEwEYO7cufTo0YPU1FS6dOlie3zOnDm0atWKtWvX8swzzzB9+vS7tHoiIiIiIiLOrcymbceOHbRp0wYfHx88PT3p2rUr69ats80/c+YM9erVIyQkBIBOnTqxceNGACwWC3l5eQBcvXqVqlWrArB582YiIyMB6NmzJ1u3bsVsNtt3zURERERERCoAt7KecPnyZfz8/GzT/v7+HDp0yDYdHBzMpUuXOHbsGKGhoaxdu5bMzEwAxo4dS//+/VmyZAlms5nly5fftEw3Nze8vLzIysoiICCgXEXXru1V/jWUO+bn5+3oEuRHtE2MSdvFmO7mdlEeSWWn455I+dzpvlJm02axWDCZTLZpq9V6w3SNGjWYNWsWcXFxWCwW+vXrh7u7OwDjx48nPj6ezp078+WXXzJq1ChWr1590/ewWq24uJT/mihXruRhsVhv+xwdROwnIyPXbsvSdrEPe24T0HaxF+0rxlSe7fJLf97lySMxHu1f9mPvPBLj0f5iH3eaRWV2SoGBgTdcKCQjIwN/f3/bdElJCYGBgSQnJ7NixQp+9atfERQURFZWFqdOnaJz584AdO3alYyMDLKzs/H397edjSsuLiY/Px8fH58yV0RERERERKSyKbNpa9euHTt37iQrK4urV6+yfv16wsPDbfNNJhPR0dGkp6djtVpZvHgxERER1KpViypVqrBnzx4A9u7dS/Xq1fH19aVDhw6kpKQAsGbNGlq1amU7OyciIiIiIiL/U+bwyICAAGJiYhg8eDBms5m+ffsSFhbG8OHDGTNmDM2aNSM+Pp5hw4ZRVFRE27ZtGTp0KCaTiXfffZepU6dSUFBA9erVSUpKAq591i02NpYePXrg7e1NQkLCXV9RERERERERZ1Rm0wbY7sF2vYULF9q+7tixIx07drzpdWFhYSQnJ9/0uI+PD/Pnz/+ZpYqIiIiIiFQ+5b/6h4iIiIiIiNxzatpEREREREQMTE2biIiIiIiIgZXrM20iIiLyy3jXqErVKrpC8p0oKDSTm1Pg6DJERBxGTZuIiMhdVLWKO7977RNHl+HUls4eSC5q2kSk8tLwSBEREREREQNT0yYiIiIiImJgatpEREREREQMTE2biIiIiIiIgalpExERERERMTA1bSIiIiIiIgampk1ERERERMTA1LSJiIiIiIgYmJo2ERERERERA1PTJiIiIiIiYmBq2kRERERERAxMTZuIiIiIiIiBuZXnSWlpabz//vsUFxczZMgQBg4ceMP8LVu2kJCQAMBDDz1EfHw8BQUFREdH256Tm5tLdnY2+/fvZ9euXYwePZrAwEAAmjRpwsyZM+21TiIiIiIiIhVGmU1beno6iYmJrFy5Eg8PD/r370/r1q0JCQkBICcnh9jYWJYsWUJISAgLFy4kMTGRiRMnkpqaCoDFYmHIkCHExMQAcOTIEaKjo3nhhRfu4qqJiIiIiIg4vzKHR+7YsYM2bdrg4+ODp6cnXbt2Zd26dbb5Z86coV69erYmrlOnTmzcuPGGZaxYsYJq1aoRGRkJwOHDh9m+fTuRkZG8+OKLXLx40Z7rJCIiIiIiUmGUeabt8uXL+Pn52ab9/f05dOiQbTo4OJhLly5x7NgxQkNDWbt2LZmZmbb5JSUlzJ8/n3nz5tke8/b2pnv37nTp0oVPP/2UmJgYli1bVu6ia9f2Kvdz5c75+Xk7ugT5EW0TY9J2Maa7uV2UR/eO9i9j0nYRKZ873VfKbNosFgsmk8k2bbVab5iuUaMGs2bNIi4uDovFQr9+/XB3d7fN37ZtG8HBwTRu3Nj2WHx8vO3rAQMG8Pbbb5Obm4u3d/lW5sqVPCwW622fo4OI/WRk5NptWdou9mHPbQLaLvaifcWYyrNdfunPW3l072j/MiZ755EYj/YX+7jTLCqzaQsMDGTPnj3XfcMM/P39bdMlJSUEBgaSnJwMwKFDhwgKCrLN37hxIxEREbZpi8XCggULGDFiBK6urrbHr/9aRERERCqXGjWrUMXDw9FlOLXCoiJy/lvo6DLkLiizaWvXrh1JSUlkZWVRrVo11q9fz9SpU23zTSYT0dHRJCcn4+/vz+LFi29o0g4cOMDw4cNt0y4uLmzYsIH777+fiIgIUlJSaN68OZ6ennZeNRERERFxFlU8PPj9orGOLsOpLX5+LqCmrSIq80IkAQEBxMTEMHjwYHr37k3Pnj0JCwtj+PDhHD58GBcXF+Lj4xk2bBjdunWjRo0aDB061Pb68+fP2y7tX2rWrFl8/PHH9OjRgxUrVjBt2jT7r5mIiIiIiEgFUK77tEVGRtqu/Fhq4cKFtq87duxIx44db/nagwcP3vRYo0aNftaFR0RERERERCqrMs+0iYiIiIiIiOOoaRMRERERETEwNW0iIiIiIiIGpqZNRERERETEwNS0iYiIiIiIGJiaNhEREREREQNT0yYiIiIiImJgatpEREREREQMTE2biIiIiIiIgalpExERERERMTA1bSIiIiIiIgampk1ERERERMTA1LSJiIiIiIgYmJo2ERERERERA1PTJiIiIiIiYmBq2kRERERERAxMTZuIiIiIiIiBuZXnSWlpabz//vsUFxczZMgQBg4ceMP8LVu2kJCQAMBDDz1EfHw8BQUFREdH256Tm5tLdnY2+/fvJycnh1dffZXz58/j6+vLnDlz8PPzs+NqiYiIiIiIVAxlnmlLT08nMTGRpUuXkpKSwvLlyzlx4oRtfk5ODrGxsSQmJpKWlkZoaCiJiYnUrl2b1NRUUlNTWbVqFfXr1yc+Ph6AOXPm0KpVK9auXcszzzzD9OnT794aioiIiIiIOLEyz7Tt2LGDNm3a4OPjA0DXrl1Zt24do0aNAuDMmTPUq1ePkJAQADp16sSwYcOYOHGibRkrVqygWrVqREZGArB582Y++eQTAHr27El8fDxmsxl3dz86H80AABkaSURBVPdyFe3iYirX8+rUql6u58ntlffnXV4eNWrbdXmVkb23CUAdL1+7L7Oysfd2qVZH+4o93I395ecuW3l055RFxmTv7aIsunN345inPLpzd7pdTFar1Xq7JyxYsIAffviBmJgYAJKTkzl06BBTp04Frp1p6969Ox9++CGhoaEkJSWxYMECjhw5AkBJSQldunRh3rx5NG7cGICmTZty4MAB3Nyu9Yzh4eEkJycTEBBwRysjIiIiIiJS0ZR5ps1isWAy/a8ztFqtN0zXqFGDWbNmERcXh8VioV+/fjecMdu2bRvBwcG2hu1WrFYrLi66JoqIiIiIiMiPldm0BQYGsmfPHtt0RkYG/v7+tumSkhICAwNJTk4G4NChQwQFBdnmb9y4kYiIiBuW6e/vT2ZmJoGBgRQXF5Ofn28bfikiIiIiIiL/U+bprXbt2rFz506ysrK4evUq69evJzw83DbfZDIRHR1Neno6VquVxYsX39CkHThwgFatWt2wzA4dOpCSkgLAmjVraNWqVbk/zyYiIiIiIlKZlPmZNrh2yf8FCxZgNpvp27cvw4cPZ/jw4YwZM4ZmzZqxefNm3n77bYqKimjbti0TJkywNWHNmzdn165dVKlSxba877//ntjYWM6fP4+3tzcJCQk0aNDg7q2liIiIiIiIkypX0yYiIiIiIiKOoat/iIiIiIiIGJiaNhEREREREQNT0yYiIiIiImJgatpEREREREQMTE2biIiIiIiIgalpczKZmZkA6KKfIv+j/UHk3lIWidya9gm5W9S0OYmSkhKysrIYMGAA+/btw2QyObqkSk8HZsfatWsXr7/+OgAmk0nbQ+QeUBYZj459jqc8kntBTZuTcHV1xdfXlwEDBvDVV19RVFSkg4IDWa1W2x8rFy5cIC8vz8EVVS55eXk8/PDDbNiwgTfeeANQUBpdSUmJo0sQO1AWGYuyyPGUR87HWfNITZsT+Pbbb/n3v/+N2WymQ4cOXLx4EdBBwVEsFostJJcsWcLQoUOZOnUqH330kYMrqxzOnz/PzJkzOX78OJs3b2bbtm1MnDgR0D5hVCUlJbi6umKxWNi5cydbtmxxdEnyCyiLjEVZ5HjKI+fjzHmkps2grt/R582bx+LFi3n55Zfx8fHhv//9L++99x6AhqY4gIvLtd1m+/btHD9+nISEBFq3bs2xY8dYvHixY4urBDw8PPD39yc1NZWTJ0/y+eef8/XXXysoDaw0IIcOHcru3buZMWMGr776Krm5uY4uTcqgLDIuZZHjKY+cjzPnkevkyZMnO7oIuVHpcIddu3axc+dOGjZsSK9evTh58iRfffUVAGfPnuXJJ5/Ew8PDwdVWPhaLhdOnT9O/f39at25Nnz59CAgIwNXVlX379nHy5ElatWrl6DIrnNJ3lb28vAgJCeH8+fN8/fXX1K9fn1GjRjFr1ixOnTpFp06d9AekQVx/JuCdd94hKCiI0aNH88UXXxAREYGXlxe+vr4OrlJ+irLI2JRFjqM8cj4VIY/UtBmQyWRi8+bNvPnmm1StWpX77ruPli1bEh4eTmhoKLVq1WLdunXUrFmThx9+2NHlVgrXf27AZDJRq1Yt6tatS2JiIuHh4QQHBxMQEIDZbObEiRM88sgjVK1a1cFVVxxWq9X2rvLx48cxmUw88cQTnDx5km3bttmCMjY2lszMTMLDwx1csZQOQbFarZw7dw6z2Uy1atWYPXs24eHhDBw4kIEDB1K/fn0aNmzo6HLlFpRFxqMscjzlkfOpKHmkps2ALBYLf/nLXxg8eDCDBg2iUaNGFBUVkZaWRpMmTWjSpAlhYWGsX7+eJ5980tHlVnjXh+Tnn39OamoqR44coUuXLjz88MOMHDmS8PBwgoKCqF+/Po8//jg1atRwcNUVS+nPf9GiRcydO5fly5djsVgYNmwYp06dYseOHfj5+TF+/HgefPBBfHx8HFyxuLi4YLVaGTlyJJ6enhQWFjJ9+nQGDBjA0KFDAdi4cSNPPvkk/v7+Dq5WbkVZZCzKImNQHjmfipJH+kybQfx4zPOVK1fYv38/cC04z549y7Zt22zvmJ05c4YzZ85gNpvvea2VTekB+qOPPmLRokUEBgaSm5vL0KFDadq0KdOmTaNv374cO3YMb29vvLy8HFxxxbR69Wo2bdrEihUr6NOnD7Nnz+aDDz5gxIgR1KlTh3Xr1uHq6kpwcLCjS5X/74MPPuDChQv06dOHZ599ln79+vH3v/+dpKQkhg4dSp06dWjatKmjy5TrKIuMS1lkHMoj51MR8sjN0QXI/94927NnD1lZWTRs2JCXX36ZqVOnsnLlSvr06UNeXh7nz5/nypUr+Pn54eXlxYwZM3B3d3d0+RXWyZMnKS4upnHjxvzwww/s37+f9957j8DAQAAaNGjAm2++yfz588nJydG2sLPr31WGa5dVHjBgAGfPnsVkMvG3v/2NIUOGUFJSwtNPP42XlxdVqlRxYMVSOgQFoKioiFq1auHm5sbChQsZPnw4EyZMYMWKFQDUrFmTwYMHA9eagdLhRuI4yiJjUhY5nvLI+VTEPNLwSAMwmUx89dVXTJkyBavVypo1a/D396djx47Mnj2bI0eOsHTpUmJiYmjatCkuLi488MADhv/ApDMrKipi5cqVPPbYYxQXF+Pp6cnf//53zGYzjzzyCABubm7s3buXzp078+ijj2p72NH1AXn27FlcXFw4d+4cQUFBHDx4kKpVq9KtWzeOHz/O7t276d+/P7Vq1XJw1ZXb9ZdR3rp1KxcvXqRp06YEBARw9OhR/vOf/xAWFmYbVte8eXPA2AFZ2SiLjEdZ5HjKI+dTUfNITZsBXLhwgVmzZvHBBx/g7e3N9u3byc7OpnHjxrz88ss0atSIiIgIWrZsaRu6oqsR3T1WqxU3NzdatGjBuXPnmDdvHv7+/gQFBXH69Gny8/N58MEH2b17N7t376ZLly76oLedlf5+//Wvf2XhwoVs3LiRwYMH8+CDD5KUlET//v05ePAghw8fJiEhAT8/PwdXLC4uLlgsFoYMGUJ6ejopKSl8//33VKtWjeDgYPbu3cv58+dp0aLFDa/Tscw4lEXGoiwyBuWR86moeaThkQ5S+s5Neno6WVlZtsslHzp0iOeff55//vOfzJw5k2eeeYbf//73ttcZ/RfK2V3/jprVasXf3x9XV1f+8Y9/8NBDD+Hv78+iRYtISUnhzJkzJCYmUrNmTQdXXTHt3r2bVatWkZycTHp6OvXq1cNsNmMymZg4cSLZ2dnMmTOHunXrOrrUSq90v5k3bx4NGjRg5syZ5OTksHr1ak6fPs2QIUMoKCjAYrE4ulT5EWWRMSmLjEV55Dwqch6paXMQk8nE7t27mT59OkuXLmXEiBFkZWVhNpvp3r277euwsDBHl1qplIZkcnIyx48fp02bNrz88svMnTuXb7/9lscff5wePXqQkZFBnTp1DH2VIWdTeqAtHZ6QlZVF3bp1bZcaz83NJSkpiTFjxtg+ZF+nTh1Hl12plQ5BKd1vrn+HuUaNGkRFRfHss88SERHB008/jZvbtcj58edDxHGURcakLHIs5ZHzqQx5ZNyBmxXckSNHeO+99+jZsyeenp60bduWnTt3smvXLvbu3cvHH39MVFQUjz76qKNLrRRyc3NtXycnJ7Ny5Uq6detGtWrV8PHxYcyYMeTn5/P5559z5coVmjRpopC0o+sPmqXbokmTJlStWpW1a9diMpnw9vbm+++/59y5cwQHBysgHez6+96sXr2aQ4cOkZ+fz+HDh7ly5QoA3t7eNGjQALPZbAtI0FkaI1EWGYuyyPGUR86nsuSRzrQ5QOk7NkVFRZw7d45Lly4RGBhIp06dOHv2LFOnTmX8+PE89thjji61Uii9IeaAAQNwdXVl586dvPjii3h4eLB161bGjRvHk08+yeDBg1mxYoUOzndB6UFz6dKl7Nu3j7p161K7dm2aNm3KN998w549e2jatCkHDx5kzJgxDq5WrFar7UPezz//PFWqVOGBBx5g/PjxnDlzhgkTJvDAAw9w6tQpvLy8aN26taNLlltQFhmLssgYlEfOpTLlkcn645uyyF2VmZnJ6NGjGTZsGM2bN+e1116jVatWDBgwwHa1oczMTOrUqeNUp2yd2alTp/D19eXSpUtYLBbOnDlDQkICAQEB9OrVi8cee4wZM2Ywbdo0jVe3s+LiYts7XikpKSxfvpx33nmHF154gS5dutC3b1/OnTvHxo0bcXNz46mnnqJRo0YOrlpKLV++nMOHDzNt2jTy8/OpXr06J0+eZPPmzdSpU4e8vDwGDhwIONcQlMpAWWQ8yiLHUh45t8qQRzrTdg9c/8vh6enJgAED+Oijjxg2bBgzZ85kwoQJFBYW8txzz+Hn52d798wZf6GcSelY9QceeACz2cynn35KtWrV6NKlC8uWLaNWrVpkZWVx4cIF8vPzde8bO9u2bRubNm2iTp06DB8+nPPnzzN27Fj++c9/4ufnx6BBg1ixYgUdO3bk9ddfvyFQxTH2799PTk4OLVu2xMvLi/z8fDIzM4Frx7b09HQWLFhAdHQ0oaGhttcZ/TLKlYWyyJiURY6nPHI+lTGPdMn/e8BkMnHw4EGsViu+vr4EBQVRo0YNFi1axEMPPcRTTz3FkiVLaN++PT4+Po4ut1KwWq22nXb37t0UFRVRvXp1srOzOX78OPXq1ePUqVPEx8ezdetW4uPjue+++xxcdcWxbds2pkyZQqdOnUhISKBGjRoEBgby1ltv8d1337Fo0SKqVq3K9OnTadeuHQEBAU57kK0oJkyYwNatW/nyyy8JDAwkJCSEevXqsXXrVr7//nvCwsLw8vLib3/7G6Ghodx///221+qPfmNQFhmPssjxlEfOp7Lmkd4muEdWrlzJvn37+OCDD6hbty7t27fn//7v/5g0aRJxcXH85S9/sV1qWe6+0p32ww8/5IsvvsDf358//vGPNGzYkNTUVDZt2kTz5s354IMPMJvN1K5d28EVVxzbt2/nnXfeIT4+nnbt2lGtWjUKCwtp1qwZDRs2pHXr1pw/f56jR49SUlJCQECAo0uu9CZPnkxubi4LFiwArt3wNysrC3d3d3r27MmGDRvYvHkz7u7u+Pv70759ewdXLD9FWWQsyiLHUh45n8qcR2ra7pLSYSjHjx/n6tWrvP7668yZM4c//vGPvPPOO9StW5cmTZpQWFhI9erVFZIOcPbsWdauXcuyZcsA8PDwoKioiJCQEP71r3+xf/9+2rdvryEQdrRz505iYmL49NNPCQkJ4cKFCyQnJ/PAAw/wxBNP0LJlSwDGjRuHr68vM2bM0JXRHCwrK4vc3FzmzJkDwNatW9m1axefffYZ4eHhNGrUiIkTJ7Jt2za8vLzo3Lkz4LyfGaholEXGpyxyDOWR86nseaQjwF1iMpnYvHkz8fHxhIWF0axZM8aPH8/EiRMZPXo0TzzxBH//+99JTEzU/W/ukdKdtvT/wsJCcnNzKSwsxNvbm4KCAhYvXkzt2rWJjo7Gw8NDIWlnRUVFWK1WcnNzKSoqYtSoUVStWpX8/HyGDh1KcXEx9913H7/5zW8YMmQI3t7eji650qtZsyZFRUVMmDCBWrVqsWnTJlq3bs1rr72G2Wxm//79+Pr60rt3b9trnPkzAxWNssh4lEXGoDxyPpU9j3T1yLvAarVy5coVYmJiePnll23v1gDk5eWxceNGvvvuO5o1a0aHDh0cWGnlcf27LKdOnSIgIACTyURSUhIWi4VRo0bh7e3Nu+++S35+PuPHj3dwxRXXV199xdSpUykqKmLixIl069YNgDNnznD58mU+//xzRowYQYMGDRxcqZT65ptvWL16NWfPnmXkyJE0btwYPz8/vv/+eyZNmsTkyZNtVxwU41AWGY+yyFiUR86nMueR3rqxo9KDsclkonbt2gQGBpKXl2d7PCUlhRUrVvDxxx/bDtoV5ZSt0ZX+jD/++GO2bNlCw4YNyc7O5sknn2Tv3r0899xzdO/endWrVzN//nwHV1uxderUCRcXFyZMmGC7CprVaqV+/foEBwfrnlAG1KZNG9q0aXPT8SouLg5fX98KG5DOSllkXMoiY1EeOZ/KnEdq2uyk9Jdn3759nDt3Di8vL7y8vDh8+DAhISHUr1+fRo0aUb9+fSwWC66uroBzX8XG2WzZsoW1a9fy0Ucf8eqrr1KzZk3atWtHWFgYDz/8MAALFiygYcOGDq604uvQoQPx8fHMmDGDvLw8oqKibghM7RfGUjq85NixY6xfv55Lly6RmZmJr68vU6ZMAbTdjEJZZHzKImNRHjmXypxHuuS/nZhMJjZt2sSbb76J2WwmNDSU3/72t6SkpHD06FG2bNnCkiVLGDBgACEhIY4ut1K4fqe1Wq18++23BAQEcPLkSY4ePcq0adP49NNPycvLo1evXoSGhlbod2iMpmHDhtx3333ExcXRoEED201KK+KB1ln8VNCVPlZ6ZTVPT0+aNm3K6NGjgYr1mQFnpywyHmWR8SmPjEd5dDOdabMDi8VCcXExK1euJC4ujl//+te2eb/+9a9p0KABGRkZREVF0aJFiwr7DoDRlP6MP/roIzIzM+natStvvvkmderU4bPPPgPgyJEjuoSyA3Xs2JG33377hnuoiOOYTKafDDyr1Wq7Gtf1x6+KHJDORllkTMoi56A8Mhbl0c3UtP1CFy5cIDc3l+DgYKpWrYrVaiUzM5OLFy8C165KdOjQIU6ePMmQIUNueK1C8u46fvw4VquV6tWrc/r0afbu3cvIkSP51a9+Ra9evcjMzCQ5ORl3d3dOnz7NuHHjHF1ypRYeHu7oEiq9Tz/9lEuXLhETE4OLi8stg89kMlFSUoKrqyt5eXlYLBZq1KhRoQPSGSiLjEtZ5HyUR46nPPppatp+geLiYl588UWuXr1KYGAgo0aNonnz5owaNYqkpCTq169Py5YtMZvNnDp1iuzsbGrWrFnhf5mMYMuWLbz55psEBwdz5coV/v3vf9OgQQMKCgoA6N27N0eOHOHzzz+ndu3avPXWWwQFBTm4ahHHSk9PZ9WqVVSrVo0XX3zxlkFZGpC5ubkMGjSIqVOn0qxZMwdWLcoi41IWifwyyqOfpkv+/0LLli3j8uXLVK9enQ0bNuDh4UHLli2xWCwkJyczePBgPvvsMyZNmqRLKd8jX3/9NQkJCUyZMoX777+f9evX88033+Di4sKpU6eYM2eOLRQtFgslJSW2DxuLVEZnz57lvvvuY8KECdStW5eTJ0/y4IMP3vTZgNKAzMnJYfTo0YwePZpWrVo5uHoBZZERKYtEfj7lUdn0dtsvFBoaarsD+7Jly2jfvj3vv/8+Z8+epaSkhObNmzNv3jyF5D2yc+dOXn75Zd555x3CwsKoWbMmjRo1wmq18tZbbxEWFsb48eM5e/YsAC4uLgpJqdRee+01PvzwQ0wmE0FBQTRp0oSBAwdy5MgR/vznPwPX9pOioiJbQI4ZM6ZSBaQzUBYZi7JI5OdTHpWPmrZf6JFHHuHZZ59l1apV/Pvf/+bzzz9n7Nix9O3blxYtWuDu7k5oaKijy6w0ioqKAGxBCLB+/XqKi4sBmDRpEg0aNGDKlCm2x0Qqq8mTJ1NYWEh8fDwAffr04YknnqBVq1YMHz6co0ePkpSUBICHhwc//PADI0aM4KWXXqpUAekMlEXGoiwS+XmUR+Wn4ZF3YPv27bz77rukp6cTHR3NoEGDbpivK3PdW1999RXTp09n/PjxnDx5kv3795OUlISHh4ftORkZGfj5+TmwShHHGjduHO7u7syYMQOAlJQUXF1diYyMBK59TurAgQMkJCQQHR1Nly5d2LdvH56envrj36CURcaiLBIpH+XRz6Om7Q698sornD59mpUrVwL/+3CkOMamTZuIi4ujevXqrF+/Hrj2zqebm5s+fC+V3vHjx4mKiuKtt94iMjKSjz/+mJSUFObPn4+/v7/teWazme+++852c1/90W98yiJjURaJ3J7y6OfTzbV/odJfmqCgIPbt20eLFi3w9vZWSDpYw4YNCQkJYfPmzTRo0IAHHngAV1fXSruDi1yvTp06NGnShDlz5rB7926OHz9OQkICdevWxWKx2PYTV1dX2819K/p9b5ydssiYlEUit6c8+vkq75rfodJfpjp16vD9999jNpsr9S+SkXTo0IGJEycyfvx41qxZ4+hyRAzlt7/9LbGxsXzzzTeEh4dTv359iouLf/KPSR3XjE1ZZFzKIpHbUx79PBoeaQd5eXl4eXk5ugz5ka1bt3L//fdz//33O7oUEcP56quvmDFjBi+99BK9e/d2dDliB8oiY1IWidye8qh8dHNtO6hevbqjS5BbCA8Pd3QJIobVqVMnAKZPn05hYSHPPvusgyuSO6UsMiZlkcjtKY/KR02bHWiMuog4o06dOlFQUMDBgwcdXYrYgbJIRJyV8qhsGh4pIiIiIiJiYJX7E30iIiIiIiIGp6ZNRERERETEwNS0iYiIiIiIGJiaNhEREREREQNT0yYiIiIiImJgatpEREREREQMTE2biIiIiIiIgf0/4pWJi/90kAgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1296x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.catplot(data=results.iloc[:,:5].query('Method == \"LSTM\" or Method == \"CNN\"'), col='Method', col_wrap=3, kind='bar', height=3, aspect=2)\n",
    "ax.set(ylim=(0.97,1))\n",
    "ax.set_xticklabels(rotation=45)\n",
    "ax = ax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> CNN and LSTM fared worse between the tested approaches. However, these methods achieved performance metrics above 97%, which is a relatively good outcome. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Average of the Metrics**\n",
    "\n",
    "Plotting the Average of the previously mentioned performance metrics to summarize the method's results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "ax = sns.barplot(data=results, y='Method', x='Average')\n",
    "ax.set(xlim=(0.98,1))\n",
    "ax.set_title('Average of the Metrics', fontsize=18, loc='left')\n",
    "ax.set_xticklabel()\n",
    "ax = ax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> As observed, on average, kNN fared slightly better compared to GB, LR, SVM, and GRU, which, in turn, achieved very similar results. However, these methods performed nearly 99.9%, which is considered a good classification outcome. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Detection rate of Normal and Attack flow records**\n",
    "\n",
    "The following plot shows the results of each method for classifying normal and attack flow records."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x648 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.catplot(data=results[['Method', 'Normal_Detect_Rate', 'Atk_Detect_Rate']], col='Method', col_wrap=3, kind='bar', height=3, aspect=2)\n",
    "ax.set(ylim=(0.97,1))\n",
    "ax.set_xticklabels(rotation=45)\n",
    "ax = ax\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> kNN achieved the best classification outcomes. \n",
    "\n",
    "> GRU showed the most balanced approach regarding classifying normal and attack flows. \n",
    "\n",
    "> Although CNN achieved a relatively good classification of attacks, the classification of normal record flows was low compared to other methods. This result can explain the Accuracy rate of this method. This situation also occurs with the LSTM method, which achieved a good classification rate for normal flows and a low classification rate for attack ones. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
